﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Linq.SqlClient;
using System.Reflection;

namespace BussinesCosea
{
    public partial class CoseaDirectos : IDisposable
    {
        #region OrdenServicio

        public string GuardaOrdenServicio(OrdenServicio orden,
            ref int iIdOrden, string comentario = "Orden Actualizada")
        {

            string folioFinal = "";
            try
            {

                db = new bdCoseaDirectosDataContext(_cadenaConexion);

                OrdenServicio os = new OrdenServicio();
                //os = db.OrdenServicios.Single(o => o.IdOrden == orden.IdOrden);

                HistoriaOrdenServicio hOrden = new HistoriaOrdenServicio();

                orden.FechaOrden = DateTime.Now;
                Empresa emp = new Empresa();
                emp = db.Empresas.Single(c => c.IdEmpresa == orden.IdEmpresa);
                orden.SerieOrden = emp.Serie.Trim();
                orden.Folio = "";
                orden.UltimoEstado = 1;
                db.OrdenServicios.InsertOnSubmit(orden);
                db.SubmitChanges();

                hOrden.IdOrden = orden.IdOrden;
                hOrden.IdEstado = 1; //Estado inicial
                hOrden.Comentario = comentario;
                hOrden.Fecha = DateTime.Now;
                db.HistoriaOrdenServicios.InsertOnSubmit(hOrden);
                db.SubmitChanges();

                OrdenServicio oser = new OrdenServicio();
                oser = db.OrdenServicios.Single(c => c.IdOrden == orden.IdOrden);
                oser.Folio = orden.SerieOrden + "-" + orden.IdOrden + "-" + DateTime.Now.Year.ToString();
                folioFinal = oser.Folio;

                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                db = null;
            }

            iIdOrden = orden.IdOrden;
            return folioFinal;

        }

        public void ActualizaOrdenServicio(OrdenServicio orden, HistoriaOrdenServicio Hestado)
        {

            try
            {

                db = new bdCoseaDirectosDataContext(_cadenaConexion);

                OrdenServicio os; //= new OrdenServicio();
                HistoriaOrdenServicio hOrden = new HistoriaOrdenServicio();
                hOrden.IdOrden = orden.IdOrden;
                hOrden.IdEstado = Hestado.IdEstado;
                hOrden.Comentario = Hestado.Comentario;
                hOrden.Fecha = DateTime.Now;
                db.HistoriaOrdenServicios.InsertOnSubmit(hOrden);
                db.SubmitChanges();


                os = db.OrdenServicios.Single(o => o.IdOrden == orden.IdOrden);
                orden.FechaOrden = DateTime.Now;
                orden.UltimoEstado = Hestado.IdEstado;

                os.FechaOrden = orden.FechaOrden;
                os.FechaRequeridaContratacion = orden.FechaRequeridaContratacion;
                os.FechaRequeridaContratacionFinal = orden.FechaRequeridaContratacionFinal;
                os.IdEmpresa = orden.IdEmpresa;
                os.TotalVacantes = orden.TotalVacantes;
                os.EdadMinima = orden.EdadMinima;
                os.EdadMaxima = orden.EdadMaxima;
                os.Genero = orden.Genero;
                os.EstadoCivil = orden.EstadoCivil;
                os.Escolaridad = orden.Escolaridad;
                os.Titulo = orden.Titulo;
                os.IdiomaExtranjero = orden.IdiomaExtranjero;
                os.Estatura = orden.Estatura;
                os.Talla = orden.Talla;
                os.Otros = orden.Otros;
                os.ExperienciaRequerida = orden.ExperienciaRequerida;
                os.Tiempo = orden.Tiempo;
                os.Conocimiento = orden.Conocimiento;
                os.Habilidades = orden.Habilidades;
                os.Actividades = orden.Actividades;
                os.SoftwareaManejar = orden.SoftwareaManejar;
                os.PersonalCargo = orden.PersonalCargo;
                os.ObservacionesSalario = orden.ObservacionesSalario;
                os.PeriodoSalario = orden.PeriodoSalario;
                os.TipoMoneda = orden.TipoMoneda;
                os.HorariosEntrevista = orden.HorariosEntrevista;
                os.CantidadPersonalCargo = orden.CantidadPersonalCargo;
                os.LugardeTrabajo = orden.LugardeTrabajo;
                os.ColoniaLugarTrabajo = orden.ColoniaLugarTrabajo;
                os.EntreCallesLugarTrabajo = orden.EntreCallesLugarTrabajo;
                os.Comentarios1 = orden.Comentarios1;
                os.Comentarios1 = orden.Comentarios1;
                os.TieneTransporte = orden.TieneTransporte;
                os.Prestaciones = orden.Prestaciones;
                os.FechaEstimadaInicio = orden.FechaEstimadaInicio;
                os.FechaEstimadaTerminacion = orden.FechaEstimadaTerminacion;
                os.SalarioMinimo = orden.SalarioMinimo;
                os.SalarioMaximo = orden.SalarioMaximo;
                os.Vigencia = orden.Vigencia;
                os.Observaciones = orden.Observaciones;
                os.IdCliente = orden.IdCliente;
                os.IdEmpresa = orden.IdEmpresa;
                os.IdPuesto = orden.IdPuesto;
                os.IdTipoContrato = orden.IdTipoContrato;
                os.IdOrden = orden.IdOrden;
                os.FechaOrden = orden.FechaOrden;
                os.UltimoEstado = orden.UltimoEstado;
                os.Garantia = orden.Garantia;
                os.PedirAuto = orden.PedirAuto;

                db.SubmitChanges();


            }
            catch (Exception ex)
            {
                throw new Exception("Error en ActualizaOrdenServicio: " + ex.Message);
            }
            finally
            {
                db = null;
            }
        }

        public void AutorizarOrdenServicio(int idOrden, string comentario = "Orden Autorizada")
        {
            asignaEstadoOrden(idOrden, 6, comentario);
        }

        public void CancelarOrdenServicio(int idOrden, string comentario = "Orden Cancelada")
        {
            asignaEstadoOrden(idOrden, 3, comentario);
        }

        public void CerrarOrdenServicio(int idOrden, string comentario = "Orden Cerrada")
        {
            asignaEstadoOrden(idOrden, 4, comentario);
        }

        public void AsignaOrdenServicio(int idOrden, int idEmpresa, string comentario = "Orden Asignada")
        {
            asignaEstadoOrden(idOrden, 7, comentario);

            try
            {

                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                //db.Connection.Open();                

                AsignacionOrdenServicio aOs = new AsignacionOrdenServicio();
                aOs.IdOrden = idOrden;
                aOs.IdEmpresa = idEmpresa;
                aOs.Fecha = DateTime.Now;
                db.AsignacionOrdenServicios.InsertOnSubmit(aOs);
                db.SubmitChanges();

            }
            catch (Exception ex)
            {
                throw new Exception("Error al asignar la orden de servicio: " + ex.Message);
            }
            finally
            {
                //                db.Connection.Close();
                db = null;
            }
        }

        public bool ValidaOrdenServicio(int idOrden)
        {
            bool valido = true;

            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);

                //Esta rutina esta muy buena para hacer inner joins
                //var resultado = db.OrdenServicios.Join(
                //    db.HistoriaOrdenServicios,
                //    f => f.IdOrden,
                //    (HistoriaOrdenServicio g) => g.IdOrden,
                //    (f, g) => new
                //    {
                //        IDOrden = f.IdOrden,
                //        FechaOrden = f.FechaOrden,
                //        SerieOrden = f.SerieOrden,
                //        IDEmpresa = f.IdEmpresa,                         
                //        IDEstado = g.IdEstado

                //    }).Where(f=> f.IDOrden == idOrden).Select( f=> new 
                //    {
                //        IDEstado = f.IDEstado 
                //    });

                //if (resultado.Count() == 0)
                //{
                //    valido = false;
                //    return valido;
                //}   

                //if (resultado.First().IDEstado == 3 |resultado.First().IDEstado == 4)
                //    valido = false;

                OrdenServicio os = new OrdenServicio();
                os = db.OrdenServicios.Single(o => o.IdOrden == idOrden);
                if (os.UltimoEstado == 3 | os.UltimoEstado == 4)
                    valido = false;


            }
            catch (Exception ex)
            {

                throw new Exception("Error al validar la orden de servicio " + ex.Message);
            }
            finally
            {
                db = null;
            }

            return valido;
        }

        public List<SPBuscaOrdenServicioResult> BuscaOrdenServicio(string criterio)
        {

            List<SPBuscaOrdenServicioResult> res = new List<SPBuscaOrdenServicioResult>();

            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);

                res = db.SPBuscaOrdenServicio(criterio).ToList<SPBuscaOrdenServicioResult>();

            }
            catch (Exception ex)
            {

                throw new Exception("Error al BuscaOrdenServicio " + ex.Message);
            }
            finally
            {
                db = null;
            }

            return res;
        }

        public OrdenServicio ObtenOrdenServicio(int idOrden)
        {
            OrdenServicio orden = new OrdenServicio();

            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                orden = db.OrdenServicios.Single(o => o.IdOrden == idOrden);
            }
            catch (Exception ex)
            {

                throw new Exception("Error al validar ObtenOrdenServicio " + ex.Message);
            }
            finally
            {
                db = null;
            }

            return orden;
        }

        public List<SPBuscaPreseleccionadosResult> BuscaPreseleccionados(int idOrden)
        {
            List<SPBuscaPreseleccionadosResult> res = new List<SPBuscaPreseleccionadosResult>();

            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                res = db.SPBuscaPreseleccionados(idOrden).ToList<SPBuscaPreseleccionadosResult>();

            }
            catch (Exception ex)
            {
                throw new Exception("Error al BuscaOrdenServicio " + ex.Message);
            }
            finally
            {
                db = null;
            }

            return res;

        }


        private void asignaEstadoOrden(int idOrden, int idEstado, string comentario)
        {
            try
            {

                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                //db.Connection.Open();                
                HistoriaOrdenServicio hOrden = new HistoriaOrdenServicio();

                hOrden.IdOrden = idOrden;
                hOrden.IdEstado = idEstado;
                hOrden.Comentario = comentario;
                hOrden.Fecha = DateTime.Now;
                db.HistoriaOrdenServicios.InsertOnSubmit(hOrden);
                db.SubmitChanges();

            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                //                db.Connection.Close();
                db = null;
            }
        }

        #endregion

        #region ValesOrdenServicio

        public void GuardaValesOrdenServicio(ValesOrdenServicio vale, TipoGuardado tipo, int numeroOrden)
        {

            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);

                if (tipo == TipoGuardado.NuevoRegistro)
                {
                    vale.IdOrden = numeroOrden;
                    db.ValesOrdenServicios.InsertOnSubmit(vale);
                }
                else
                {

                    ValesOrdenServicio va = db.ValesOrdenServicios.Single(c => c.IdVale == vale.IdVale);
                    va.Concepto = vale.Concepto;
                    va.Cantidad = vale.Cantidad;
                    va.Fecha = DateTime.Now;
                    va.Periocidad = vale.Periocidad;
                    va.Porcentaje = vale.Porcentaje;
                }
                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                db = null;
            }
        }

        public void EliminaValeOrdenServicio(int idVale)
        {
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                ValesOrdenServicio vale = db.ValesOrdenServicios.Single(c => c.IdVale == idVale);
                db.ValesOrdenServicios.DeleteOnSubmit(vale);
                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                db = null;
            }
        }

        public List<ValesOrdenServicio> ObtenValesPorOrden(int idOrden)
        {
            List<ValesOrdenServicio> res = new List<ValesOrdenServicio>();
            db = new bdCoseaDirectosDataContext(_cadenaConexion);
            try
            {
                var oVales =
                    (from vals in db.ValesOrdenServicios
                     where vals.IdOrden == idOrden
                     select vals);
                res = oVales.ToList<ValesOrdenServicio>();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                db = null;
            }

            return res;
        }

        public ValesOrdenServicio ObtenValeOrdenServicio(int idVale)
        {
            ValesOrdenServicio vale = new ValesOrdenServicio();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                vale = db.ValesOrdenServicios.Single(c => c.IdVale == idVale);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                db = null;
            }
            return vale;
        }

        public bool TieneValesOrdenServicio(int idOrden)
        {
            bool result = false;
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                var vals =
                    (from vls in db.ValesOrdenServicios
                     where vls.IdOrden == idOrden
                     select vls);

                if (vals.Count() > 0)
                    result = true;

            }
            catch (Exception ex)
            {
                throw new Exception("Error en TieneValesOrdenServicio: " + ex.Message);                
            }
            finally
            {
                db = null;
            }


            return result;
        }

        #endregion

        #region BonoOrdenServicio

        public void GuardaBonoOrdenServicio(BonosOrdenServicio bono, TipoGuardado tipo, int numeroOrden)
        {

            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);

                if (tipo == TipoGuardado.NuevoRegistro)
                {
                    bono.IdOrden = numeroOrden;
                    db.BonosOrdenServicios.InsertOnSubmit(bono);
                }
                else
                {
                    BonosOrdenServicio bo = db.BonosOrdenServicios.Single(c => c.IdBono == bono.IdBono);
                    bo.Concepto = bono.Concepto;
                    bo.Cantidad = bono.Cantidad;
                    bo.Fecha = DateTime.Now;
                    bo.Periocidad = bono.Periocidad;
                    bo.Porcentaje = bono.Porcentaje;
                }
                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                db = null;
            }
        }


        public void EliminaBonoOrdenServicio(int idBono)
        {
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                BonosOrdenServicio bono = db.BonosOrdenServicios.Single(c => c.IdBono == idBono);
                db.BonosOrdenServicios.DeleteOnSubmit(bono);
                db.SubmitChanges();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                db = null;
            }
        }

        public List<BonosOrdenServicio> ObtenBonosPorOrden(int idOrden)
        {
            List<BonosOrdenServicio> res = new List<BonosOrdenServicio>();
            db = new bdCoseaDirectosDataContext(_cadenaConexion);
            try
            {                
                var oBonos =
                    (from bons in db.BonosOrdenServicios
                     where bons.IdOrden == idOrden
                     select bons);
                res = oBonos.ToList<BonosOrdenServicio>();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                db = null;
            }

            return res;
        }


        public BonosOrdenServicio ObtenBonoOrdenServicio(int idBono)
        {
            BonosOrdenServicio bono = new BonosOrdenServicio();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                bono = db.BonosOrdenServicios.Single(c => c.IdBono == idBono);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                db = null;
            }
            return bono;
        }

        public bool TieneBonoOrdenServicio(int idOrden)
        {
            bool result = false;
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                var bons =
                    (from bns in db.BonosOrdenServicios
                     where bns.IdOrden == idOrden
                     select bns);

                if (bons.Count() > 0)
                    result = true;

            }
            catch (Exception ex)
            {
                throw new Exception("Error en TieneBonoOrdenServicio: " + ex.Message);
            }
            finally
            {
                db = null;
            }


            return result;
        }


        #endregion

        #region EstadosOrdenServicio

        public List<EstadosOrdenServicio> ObtenEstadosOrdenServicio()
        {
            List<EstadosOrdenServicio> res = new List<EstadosOrdenServicio>();

            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);
                var edos = (from edo in db.EstadosOrdenServicios select edo);
                res = edos.ToList<EstadosOrdenServicio>();
            }
            catch (Exception ex)
            {
                throw new Exception("Error en ObtenEstadosOrdenServicio: " + ex.Message);
            }

            return res;
        }

        #endregion

        #region HistoriaOrdenServicio

        public List<ObtenHistoriaOrdenServicioResult> ObtenHistoriaOrdenServicio(int idOrden)
        {
            List<ObtenHistoriaOrdenServicioResult> res = new List<ObtenHistoriaOrdenServicioResult>();
            try
            {
                db = new bdCoseaDirectosDataContext(_cadenaConexion);

                res = db.ObtenHistoriaOrdenServicio(idOrden).ToList<ObtenHistoriaOrdenServicioResult>();

            }
            catch (Exception ex)
            {
                throw new Exception("Error al ObtenHistoriaOrdenServicio " + ex.Message);
            }
            finally
            {
                db = null;
            }

            return res;
        }

        #endregion
                
    }
}
